//----------------------------------------------------------------------
//Copyright (C) 2016-2026 烟台东方威思顿电气股份有限公司电表软件研发部 
//创建人	胡春华
//创建日期	2016.8.10
//描述		公共函数接口文件
//修改记录	
//----------------------------------------------------------------------
#include <math.h>
#include "CommFunc_API.h"
#include <stdio.h>
#include <stdint.h>
//-----------------------------------------------
//			本文件使用的宏定义
//-----------------------------------------------
#define CRC32_INIT  0x55555555
#define CRC32_XOROT 0xffffffff

//-----------------------------------------------
//		本文件使用的结构体，共用体，枚举
//-----------------------------------------------

//-----------------------------------------------
//				全局使用的变量，常量
//-----------------------------------------------

//-----------------------------------------------
//				本文件使用的变量，常量
//-----------------------------------------------
static const DWORD CRC32_Table[256] =
{
  0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA,
  0x076DC419, 0x706AF48F, 0xE963A535, 0x9E6495A3,
  0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988,
  0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91,
  0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE,
  0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7,
  0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC,
  0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5,
  0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172,
  0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B,
  0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940,
  0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59,
  0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116,
  0x21B4F4B5, 0x56B3C423, 0xCFBA9599, 0xB8BDA50F,
  0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924,
  0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D,
  0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A,
  0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433,
  0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818,
  0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01,
  0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E,
  0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457,
  0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA, 0xFCB9887C,
  0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65,
  0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2,
  0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB,
  0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0,
  0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9,
  0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086,
  0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F,
  0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4,
  0x59B33D17, 0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD,
  0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A,
  0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683,
  0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8,
  0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1,
  0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE,
  0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7,
  0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC,
  0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5,
  0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252,
  0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B,
  0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60,
  0xDF60EFC3, 0xA867DF55, 0x316E8EEF, 0x4669BE79,
  0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236,
  0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F,
  0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04,
  0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D,
  0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A,
  0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713,
  0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38,
  0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21,
  0x86D3D2D4, 0xF1D4E242, 0x68DDB3F8, 0x1FDA836E,
  0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777,
  0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C,
  0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45,
  0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2,
  0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB,
  0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0,
  0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9,
  0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6,
  0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF,
  0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94,
  0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D
};





static const unsigned char auchCRCHi[] = {
	0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 
	0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 
	0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 
	0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 
	0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 
	0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 
	0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 
	0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 
	0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 
	0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 
	0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 
	0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 
	0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 
	0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 
	0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 
	0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 
	0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 
	0x81, 0x40};

// -----------------------------------------------------------------------------
// DESCRIPTION: CRC校验的低位字节表
// -----------------------------------------------------------------------------
static const unsigned char auchCRCLo[] = {
	0x00, 0xC0, 0xC1, 0x01, 0xC3, 0x03, 0x02, 0xC2, 0xC6, 0x06, 0x07, 0xC7, 0x05, 0xC5, 
	0xC4, 0x04, 0xCC, 0x0C, 0x0D, 0xCD, 0x0F, 0xCF, 0xCE, 0x0E, 0x0A, 0xCA, 0xCB, 0x0B, 
	0xC9, 0x09, 0x08, 0xC8, 0xD8, 0x18, 0x19, 0xD9, 0x1B, 0xDB, 0xDA, 0x1A, 0x1E, 0xDE, 
	0xDF, 0x1F, 0xDD, 0x1D, 0x1C, 0xDC, 0x14, 0xD4, 0xD5, 0x15, 0xD7, 0x17, 0x16, 0xD6, 
	0xD2, 0x12, 0x13, 0xD3, 0x11, 0xD1, 0xD0, 0x10, 0xF0, 0x30, 0x31, 0xF1, 0x33, 0xF3, 0xF2, 
	0x32, 0x36, 0xF6, 0xF7, 0x37, 0xF5, 0x35, 0x34, 0xF4, 0x3C, 0xFC, 0xFD, 0x3D, 0xFF, 0x3F, 
	0x3E, 0xFE, 0xFA, 0x3A, 0x3B, 0xFB, 0x39, 0xF9, 0xF8, 0x38, 0x28, 0xE8, 0xE9, 0x29, 0xEB, 
	0x2B, 0x2A, 0xEA, 0xEE, 0x2E, 0x2F, 0xEF, 0x2D, 0xED, 0xEC, 0x2C, 0xE4, 0x24, 0x25, 
	0xE5, 0x27, 0xE7, 0xE6, 0x26, 0x22, 0xE2, 0xE3, 0x23, 0xE1, 0x21, 0x20, 0xE0, 0xA0, 0x60, 
	0x61, 0xA1, 0x63, 0xA3, 0xA2, 0x62, 0x66, 0xA6, 0xA7, 0x67, 0xA5, 0x65, 0x64, 0xA4, 0x6C, 
	0xAC, 0xAD, 0x6D, 0xAF, 0x6F, 0x6E, 0xAE, 0xAA, 0x6A, 0x6B, 0xAB, 0x69, 0xA9, 0xA8, 
	0x68, 0x78, 0xB8, 0xB9, 0x79, 0xBB, 0x7B, 0x7A, 0xBA, 0xBE, 0x7E, 0x7F, 0xBF, 0x7D, 
	0xBD, 0xBC, 0x7C, 0xB4, 0x74, 0x75, 0xB5, 0x77, 0xB7, 0xB6, 0x76, 0x72, 0xB2, 0xB3, 0x73, 
	0xB1, 0x71, 0x70, 0xB0, 0x50, 0x90, 0x91, 0x51, 0x93, 0x53, 0x52, 0x92, 0x96, 0x56, 0x57, 
	0x97, 0x55, 0x95, 0x94, 0x54, 0x9C, 0x5C, 0x5D, 0x9D, 0x5F, 0x9F, 0x9E, 0x5E, 0x5A, 0x9A, 
	0x9B, 0x5B, 0x99, 0x59, 0x58, 0x98, 0x88, 0x48, 0x49, 0x89, 0x4B, 0x8B, 0x8A, 0x4A, 0x4E, 
	0x8E, 0x8F, 0x4F, 0x8D, 0x4D, 0x4C, 0x8C, 0x44, 0x84, 0x85, 0x45, 0x87, 0x47, 0x46, 0x86, 
	0x82, 0x42, 0x43, 0x83, 0x41, 0x81, 0x80, 0x40};


unsigned short CRC16( unsigned char *puchMsg, unsigned long usDataLen )
{
    unsigned char uchCRCHi;// high byte of CRC initialized
    unsigned char uchCRCLo;// low byte of CRC initialized
    unsigned uIndex;// will index into CRC lookup table

    uchCRCHi = 0xFF;
    uchCRCLo = 0xFF;
    while ( usDataLen-- )
    {
        // calculate the CRC
        uIndex = uchCRCHi^(unsigned char)(*puchMsg++);
        uchCRCHi = uchCRCLo^auchCRCHi[uIndex];
        uchCRCLo = auchCRCLo[uIndex];
    }
    return ( uchCRCHi<<8|uchCRCLo );
}
//-----------------------------------------------
//				内部函数声明
//-----------------------------------------------

//-----------------------------------------------
//				函数定义
//-----------------------------------------------
//-----------------------------------------------
//函数功能: 一个字节的BCD码数据转换为HEX码数据
//
//参数: 
//			In[in]					要转换的数据
//                    
//返回值:  	转换后的HEX码数据
//
//备注:   
//-----------------------------------------------
BYTE lib_BBCDToBin(BYTE Input)
{
	BYTE   Hex;
	
	if( lib_CheckBCD( Input ) == FALSE )
	{
//		ASSERT( FALSE, 0 );
	}
   
   Hex = Input & 0xF0;
   Hex >>= 1;
   Hex += (Hex>>2);
   Hex += Input & 0x0F;
   return Hex;
}


//-----------------------------------------------
//函数功能: 多个字节的BCD码数据转换为HEX码数据
//
//参数: 
//          WORD Num                数据个数
//
//			pIn[in]					要转换的数据
//         
//          BYTE* pOut              输出的数据
//
//返回值:  	转换后的HEX码数据
//
//备注:   
//-----------------------------------------------
void lib_MultipleBBCDToBin( WORD Num, BYTE* pIn, BYTE* pOut )
{
   WORD i;

   for( i=0; i<Num; i++ )
   {
	   pOut[i] = lib_BBCDToBin( pIn[i] );
   }
}

//-----------------------------------------------
//函数功能: 多个字节的BCD码数据转换为HEX码数据
//
//参数: 
//          WORD Num                数据个数
//
//			pIn[in]					要转换的数据
//         
//          BYTE* pOut              输出的数据
//
//返回值:  	转换后的HEX码数据

//备注:   
//-----------------------------------------------
void lib_MultipleBBinToBCD( WORD Num, BYTE* pIn, BYTE* pOut )
{
   WORD i;

   for( i=0; i<Num; i++ )
   {
	   pOut[i] = lib_BBinToBCD( pIn[i] );
   }
}

//-----------------------------------------------
//函数功能: 一个字节的HEX码数据转换为BCD码数据
//
//参数: 
//			Input[in]					要转换的数据
//                    
//返回值:  	转换后的BCD码数据
//
//备注:   
//-----------------------------------------------
BYTE lib_BBinToBCD(BYTE Input)
{
	Input %= 100;
	return (Input / 10) * 0x10 + (Input%10);
}


//-----------------------------------------------
//函数功能: 一个WORD类型的BCD码数据转换为HEX码数据
//
//参数: 
//			Input[in]					要转换的数据
//                    
//返回值:  	转换后的HEX码数据
//
//备注:   
//-----------------------------------------------
WORD lib_WBCDToBin(WORD Input)
{
	//这个地方不再判断是否为BCD码，BBCDToBina这个函数判了
	return lib_BBCDToBin( (Input>>8)&0xff ) * 100 + lib_BBCDToBin(Input&0xff);
}


//-----------------------------------------------
//函数功能: 一个WORD类型的HEX码数据转换为BCD码数据
//
//参数: 
//			Input[in]					要转换的数据
//                    
//返回值:  	转换后的BCD码数据
//
//备注:   
//-----------------------------------------------
WORD lib_WBinToBCD(WORD Input)
{
	Input %= 10000;
	//这个地方不再判断是否超BCD码表达范围，BBinToBCDa这个函数判了
	return lib_BBinToBCD( (Input/100) ) * 0x100 + lib_BBinToBCD(Input%100);
}


//-----------------------------------------------
//函数功能: 一个DWORD类型的BCD码数据转换为HEX码数据
//
//参数: 
//			Input[in]					要转换的数据
//                    
//返回值:  	转换后的HEX码数据
//
//备注:   
//-----------------------------------------------
DWORD lib_DWBCDToBin(DWORD Input)
{
	//这个地方不再判断是否为BCD码，BBCDToBina这个函数判了
	return ((DWORD)lib_WBCDToBin( (Input>>16)&0xffff )) * 10000 + (DWORD)lib_WBCDToBin(Input&0xffff);
}


//-----------------------------------------------
//函数功能: 一个DWORD类型的HEX码数据转换为BCD码数据
//
//参数: 
//			Input[in]					要转换的数据
//                    
//返回值:  	转换后的BCD码数据
//
//备注:   
//-----------------------------------------------
DWORD lib_DWBinToBCD(DWORD Input)
{
	Input %= 100000000;
	//这个地方不再判断是否超BCD码表达范围，BBinToBCDa这个函数判了
	return ((DWORD)lib_WBinToBCD( (Input/10000) )) * 0x10000 + (DWORD)lib_WBinToBCD(Input%10000);
}

//-----------------------------------------------
//函数功能: 一个SQWORD类型的BCD码数据转换为HEX码数据
//
//参数: 
//			Input[in]					要转换的数据
//                    
//返回值:  	转换后的HEX码数据
//
//备注:   
//-----------------------------------------------
SQWORD lib_QWBCDToBin(SQWORD Input)
{
	//这个地方不再判断是否为BCD码，BBCDToBina这个函数判了
	return ((SQWORD)lib_DWBCDToBin( (Input>>32)&0xffffffff )) * 100000000 + (SQWORD)lib_DWBCDToBin(Input&0xffffffff);
}

//-----------------------------------------------
//函数功能: 一个SQWORD类型的HEX码数据转换为BCD码数据
//
//参数: 
//			Input[in]					要转换的数据
//                    
//返回值:  	转换后的BCD码数据
//
//备注:   
//-----------------------------------------------
SQWORD lib_QWBinToBCD(SQWORD Input)
{
	Input %= (SQWORD)10000000000000000;
	//这个地方不再判断是否超BCD码表达范围，BBinToBCDa这个函数判了
	return ((SQWORD)lib_DWBinToBCD( (Input/100000000) )) * 0x100000000 + (SQWORD)lib_DWBinToBCD(Input%100000000);
}


//-----------------------------------------------
//函数功能: 计算10的n次幂的值
//
//参数: 
//			PowNum[in]			幂
//                    
//返回值:  	计算后的值
//
//备注:   没有判断范围，最大一个DWORD
//-----------------------------------------------
DWORD lib_MyPow10( BYTE PowNum )
{
	BYTE i;
	DWORD dw;
	
	dw = 1;
	for(i=0; i<PowNum; i++)
	{
		dw *= 10;
	}
	
	return dw;
}


//-----------------------------------------------
//函数功能: 检查一个字节的数据是否为BCD码
//
//参数: 
//			Input[in]					要判断的数据
//                    
//返回值:  	TRUE:数据符合BCD码		FALSE:数据不是BCD码
//
//备注:   
//-----------------------------------------------
BOOL lib_CheckBCD(BYTE Input)
{
	if( (Input&0x0f) > 0x09 )
	{
		return FALSE;
	}

	if( (Input>>4) > 0x09 )
	{
		return FALSE;
	}

	return TRUE;
}


//-----------------------------------------------
//函数功能: 计算单字节累加和，超出一个字节的部分舍弃
//
//参数: 
//	ptr[in]:	输入缓冲
//
//	Length[in]:	缓冲长度
//                    
//返回值:	单字节累加和
//
//备注: 
//-----------------------------------------------
BYTE lib_CheckSum(BYTE * ptr, WORD Length)
{
	WORD i;
	BYTE Sum = 0;

	for(i=0; i<Length; i++)
	{
		Sum += *ptr;
		ptr ++;
	}

	return Sum;
}

//-----------------------------------------------
//函数功能: 计算CRC32校验
//
//参数: 
//	pBuf[in]:	输入缓冲
//
//	wSize[in]:	缓冲长度，不包括校验
//                    
//返回值:	CRC32校验
//
//备注: 
//-----------------------------------------------
DWORD lib_CheckCRC32( BYTE *pBuf, WORD wSize)
{
	DWORD dwValue;

	/* init the start value */
	dwValue = CRC32_INIT;

	/* calculate CRC32 */
	while (wSize --)
	{
		dwValue = CRC32_Table[(dwValue ^ *pBuf++) & 0xFF] ^ (dwValue >> 8);
	}
	/* XOR the output value */
	return dwValue ^ CRC32_XOROT;
}

//-----------------------------------------------
//函数功能: 先检查缓冲中校验正确性，如果不正确，将计算的校验填充到校验区，校验固定认为是CRC32
//
//参数: 
//			p[in]				要计算校验的数据指针
//			Size[in]			缓冲存储数据大小，包括校验
//			Fix[in]				是否修复缓冲内的校验 0：不修复 1：修复
//                    
//返回值:  	TRUE:缓冲内的校验正确	FALSE:缓冲内的校验不正确
//
//备注:   
//-----------------------------------------------
BOOL lib_CheckSafeMemVerify(BYTE * p, WORD Size, WORD Fix)
{
	DWORD	CRC1,CRC2;

	memcpy( (BYTE *)&CRC1, (p+Size-sizeof(DWORD)), sizeof(DWORD) );

	CRC2 = lib_CheckCRC32( p, (Size - sizeof(DWORD)) );

	if( CRC1 != CRC2 )
	{
		if( Fix == REPAIR_CRC )
		{
			// 填充正确校验
			memcpy( (p+Size-sizeof(DWORD)), (BYTE *)&CRC2, sizeof(DWORD) );	
		}

		return FALSE;
	}

	return TRUE;
}
//--------------------------------------------------
//函数功能:  HEX转ASCII
//         
//参数:      无
//                 
//返回值:    无
//         
//备注:      无
//--------------------------------------------------
void HexToAscii(unsigned char *pHexStr,unsigned char *pAscStr,int Len)
{
	char Nibble[2];
	unsigned char Buffer[30];
	int i = 0;
	int j = 0;

	for(i=0;i<Len;i++)
	{
		Nibble[0]=pHexStr[i] >> 4 & 0X0F;
		Nibble[1]=pHexStr[i] & 0x0F;
		for(j=0;j<2;j++)
		{
			if(Nibble[j]<10)
			{
				Nibble[j]=Nibble[j]+0x30;
			}
			else if(Nibble[j]<16)
			{
				Nibble[j]=Nibble[j]-10+'A';
			}
			else
			{
				
			}
		}
		memcpy(Buffer+i*2,Nibble,2);
	}
	Buffer[2*Len]=0x00;
	memcpy(pAscStr,Buffer,2*Len);
//	pAscStr[2*Len]=0x00;
}

//--------------------------------------------------
//函数功能:  字符串转HEX
//         
//参数:      无
//                 
//返回值:    无
//         
//备注:      无
//--------------------------------------------------
BOOL StringToHexGroup(unsigned char *OutHexBuffer, unsigned char *InStrBuffer, unsigned int strLength)
{
	unsigned int i, k=0;
	unsigned char HByte,LByte;
	if(strLength%2 !=0)
	return FALSE;

	for(i=0; i<strLength; i=i+2)
	{
		if(InStrBuffer[i]>='0' && InStrBuffer[i]<='9')
		{
			HByte=InStrBuffer[i]-'0';
		}
		
		else if(InStrBuffer[i]>='A' && InStrBuffer[i]<='F')
		{
			HByte=InStrBuffer[i]-'A' +10;
		}
		
        else if(InStrBuffer[i]>='a' && InStrBuffer[i]<='f')
		{
			HByte=InStrBuffer[i]-'a' +10;
		}
        
		else
		{
			HByte=InStrBuffer[i];
			return FALSE;
		}
		HByte=HByte <<4;
		HByte = HByte & 0xF0;
		
		if(InStrBuffer[i+1]>='0' && InStrBuffer[i+1]<='9')
		{
			LByte=InStrBuffer[i+1]-'0';
		}
		
		else if(InStrBuffer[i+1]>='A' && InStrBuffer[i+1]<='F')
		{
			LByte=InStrBuffer[i+1]-'A' +10;
		}
		else if(InStrBuffer[i+1]>='a' && InStrBuffer[i+1]<='f')
		{
			LByte=InStrBuffer[i+1]-'a' +10;
		}
		else
		{
			LByte=InStrBuffer[i];
			return FALSE;
		}
		OutHexBuffer[k++]=HByte |LByte;
	}
	return TRUE;
}
//rt-thread 申请内存
BOOL StringToHexGroupBW(unsigned char *OutHexBuffer, unsigned char *InStrBuffer, unsigned int strLength)
{
    uint16_t _len=0;
    uint32_t Rev_addr=0;
    if( strLength ==0)
    {
        return FALSE;
    }
    uint8_t* addr_malloc =  rt_malloc(strLength+1);
    
    if( strLength %2 !=0)
    {
        memcpy(addr_malloc+1,InStrBuffer,strLength);
        addr_malloc[0] ='0';
        strLength +=1;
    }
    else
    {
        memcpy(addr_malloc,InStrBuffer,strLength);
    }
    StringToHexGroup((unsigned char *)&Rev_addr, addr_malloc, strLength);
    lib_InverseData((unsigned char *)&Rev_addr, strLength/2);
    memcpy(OutHexBuffer, (unsigned char *)&Rev_addr, strLength/2);
    
    rt_free(addr_malloc);
    return TRUE;
}
//-----------------------------------------------
//函数功能: 数组成员翻转函数
//
//参数:		Buf[in]	输入数据
//			Len[in]	数据长度
//返回值: 	无
//		   
//备注:   	
//-----------------------------------------------
void lib_InverseData( BYTE *Buf, WORD Len )
{
	WORD i;
	BYTE Temp08;
	
	for( i=0; i<Len/2; i++ )
	{
		Temp08 = Buf[i];
		Buf[i] = Buf[Len-1-i];
		Buf[Len-1-i] = Temp08;//交换数据
	}
}
/*******************************************************************************
功能描述：	INT32U型HEX(BIN)数据转换为2~4字节BCD格式
输入参数：	*pDest:		目标数据指针
			*pSour:		源数据指针
			len:		转换字节数
返回参数：
函数说明：
*******************************************************************************/
void uLONG_nBCD(uint8_t *pDest, const uint8_t *pSour, uint8_t len)
{
	uint8_t	i, j, k;
	uint32_t	u32 = 0;
	
	switch (len)
	{
	case 2:
		u32 = pSour[0] | pSour[1]<<8;
		break;
	case 3:
		u32 = pSour[0] | pSour[1]<<8 | pSour[2]<<16;
		break;
	case 4:
		u32 = pSour[0] | pSour[1]<<8 | pSour[2]<<16 | pSour[3]<<24;
		break;
	default:
		break;
	}
	for (i=0; i<len; i++)
	{
		j = u32%100;
		k = j%10;
		j /=10;
		j <<= 4;
		j |= k;
		u32 /= 100;
		*(pDest+i) = j;
	}
}

//-----------------------------------------------
//函数功能: 两个数组大小比较
//
//参数:		BufA[in]	输入数组A
//			BufB[in]	输入数组B
//			Len[in]		比较长度
//返回值: 	1:A>B; 2:A<B; 3:A=B
//		   
//备注:   	
//-----------------------------------------------
WORD lib_CmpData( BYTE *BufA, BYTE *BufB, WORD Len )
{
	WORD i;

	for( i=0; i<Len; i++ )
	{
		if( BufA[Len-1-i] > BufB[Len-1-i] )
		{
			return 1; //A>B
		}
		else
		{
			if( BufA[Len-1-i] < BufB[Len-1-i] )
			{
				return 2; //A<B
			}
		}
	}

	return 3; //A=B
}
//--------------------------------------------------
//功能描述:  高位反转
//         
//参数:      
//         
//返回值:    
//         
//备注内容:  无
//--------------------------------------------------
unsigned char api_reverse(unsigned char a)
{

    a = (a & 0xf0)>>4 | (a & 0x0f) << 4;
    return a;
}

//--------------------------------------------------
//功能描述:  把BufB的数据倒序给BufA
//         
//参数:      BufA[out] 		输出数据的缓冲
//         
//           BufB[in]		输入数据的缓冲
//         
//           Len[in]		数据长度
//         
//返回值:    
//         
//备注内容:  无
//--------------------------------------------------
void lib_ExchangeData(BYTE *BufA, BYTE *BufB, BYTE Len )
{
   BYTE n;
   BYTE Buf[255];
   
   memcpy( Buf, BufB, Len );
   
   for( n=0; n<Len; n++ )
   {
	   BufA[n] = Buf[Len - 1 - n];
   }
}

//--------------------------------------------------
//功能描述:  把len个BufB的数据按位倒序给BufA  bit15~bit0  -> bit0~bit15
//         
//参数:      BufA[out] 		输出数据的缓冲  可以输出缓冲指针一样
//         
//           BufB[in]		输入数据的缓冲
//         
//           Len[in]		数据长度
//         
//返回值:    
//         
//备注内容:  无
//--------------------------------------------------
void lib_ExchangeBit(BYTE *BufA, BYTE *BufB, BYTE Len )
{
	BYTE i;
	for( i = 0; i < Len; i++ )
	{
		BufA[i] = BufB[i];
		BufA[i] = (((BufA[i] >> 1) & 0x55) | ((BufA[i] & 0x55) << 1));		//交换每两位
		BufA[i] = (((BufA[i] >> 2) & 0x33) | ((BufA[i] & 0x33) << 2));  	//交换每四位的前两位和后两位
		BufA[i] = (( BufA[i] >> 4 ) | (BufA[i] << 4));				  		//交换前四位和后四位
	}

	lib_InverseData( BufA, Len );//交换数据
}
//--------------------------------------------------
//功能描述:  把len个BufB的数据按位倒序给BufA  bit15~bit0  -> bit0~bit15  不翻转
//         
//参数:      BufA[out] 		输出数据的缓冲  可以输出缓冲指针一样
//         
//           BufB[in]		输入数据的缓冲
//         
//           Len[in]		数据长度
//         
//返回值:    
//         
//备注内容:  无
//--------------------------------------------------
void lib_ExchangeBitNOInverse(BYTE *BufA, BYTE *BufB, DWORD Len )
{
	DWORD i;
	for( i = 0; i < Len; i++ )
	{
		BufA[i] = BufB[i];
		BufA[i] = (((BufA[i] >> 1) & 0x55) | ((BufA[i] & 0x55) << 1));		//交换每两位
		BufA[i] = (((BufA[i] >> 2) & 0x33) | ((BufA[i] & 0x33) << 2));  	//交换每四位的前两位和后两位
		BufA[i] = (( BufA[i] >> 4 ) | (BufA[i] << 4));				  		//交换前四位和后四位
	}
}
//--------------------------------------------------
//功能描述:  判断字节是否为bcd码
//         
//参数:      BYTE Value[in]
//         
//返回值:    BYTE   TRUE:BCD FALSE:非BCD  
//         
//备注内容:  无
//--------------------------------------------------
BYTE lib_IsBCD( BYTE Value )
{
	if( ((Value&0xF0)<=0x90) && ((Value&0x0F)<=0x09) )
	{
		return TRUE;
	}
	else
	{
		return FALSE;
	}
}
//--------------------------------------------------
//功能描述:  判断字节串是否为bcd码
//         
//参数:      BYTE *Buf[in]
//         
//           BYTE Len[in]
//         
//返回值:    BYTE   TRUE:BCD FALSE:非BCD  
//         
//备注内容:  无
//--------------------------------------------------
BYTE lib_IsMultiBcd( BYTE *Buf, BYTE Len )
{
	BYTE i;
	
	for( i=0; i<Len; i++ )
	{
		if( lib_IsBCD(Buf[i]) != TRUE )		return FALSE;
	}
	
	return TRUE;
}
//--------------------------------------------------
//功能描述:  对指定字节数的两个数据进行异或
//         
//参数:      BYTE *BufA[in]  输入数据( 最后作为输出数据进行输出)
//         
//           BYTE *BufB[in]  输入数据
//         
//           BYTE Num[in]	   字节个数
//         
//返回值:    
//         
//备注内容:  无
//--------------------------------------------------
void lib_XorData( BYTE *BufA, BYTE *BufB, WORD Num )
{
	WORD i;

	for( i=0; i<Num; i++ )
	{
		BufA[i] ^= BufB[i];
	}
}

//--------------------------------------------------
//函数功能: 判断指针p里面的数据是否都是AssignNum指定的数据
//
//参数:    P[in]       数据的缓冲
//			AssignNum[in] 要判断的指定数据
//         Length[in]  数据的长度
//
//返回值:TRUE、FALSE
//
//备注:
//--------------------------------------------------
BOOL lib_IsAllAssignNum(BYTE *p, BYTE AssignNum, WORD Length)
{
	WORD i;
	for( i = 0; i < Length; i++ )
	{
		if( p[i] != AssignNum )
		{
			return FALSE;
		}
	}
	
	return TRUE;
}

/////////////////////////////////////////////////////////
//
//功能：十进制转BCD码
//
//输入：int Dec                      待转换的十进制数据
//      int length                   BCD码数据长度
//
//输出：unsigned char *Bcd           转换后的BCD码
//
//返回：0  success
//
//思路：原理同BCD码转十进制
//
//////////////////////////////////////////////////////////
int Dec2BCD( long Dec, unsigned char* Bcd, int length )
{
    int i, temp;
    
    unsigned long data = abs(Dec);
    
    for( i = 0; i < length; i++ )
    {
        temp = data % 100;
        Bcd[i] = ( ( temp / 10 ) << 4 ) + ( ( temp % 10 ) & 0x0F );
        data /= 100;
    } //低在前
    
    if( Dec < 0 && i >= 1 )
    {
        Bcd[i - 1] |= ( 1 << 7 );
    }
    
    return 0;
}

/*******************************************************************************
 * 函数名称: uint8_t Bcd2HexChar(uint8_t bcd)
 * 函数功能: char型数据BCD-HEX转换
 * 入口参数: BCD数据
 * 出口参数: HEX数据
 * 注意事项: 无
*******************************************************************************/
uint8_t Bcd2HexChar( uint8_t bcd )
{
    return ( ( bcd >> 4 ) * 10 + ( bcd & 0x0F ) );
}

/////////////////////////////////////////////////////////
//
//功能：单字节十进制转BCD码
//
//输入：int Dec                      待转换的十进制数据
//      int length                   BCD码数据长度
//
//输出：unsigned char *Bcd           转换后的BCD码
//
//返回：0  success
//
//思路：原理同BCD码转十进制
//
//////////////////////////////////////////////////////////
unsigned char DecToBCD( uint8_t Dec )
{

     return  ((( Dec / 10 ) << 4)  +  (( Dec % 10 ) & 0x0F) );   //低在前

}

//////////////////////////////////////////////////////////
//功能：求权
//输入：int base                    进制基数
//      int times                   权级数
//返回：unsigned long               当前数据位的权
//////////////////////////////////////////////////////////
unsigned long power( int base, int times )
{
    int i;
    unsigned long rslt = 1;
    for( i = 0; i < times; i++ )
    {
        rslt *= base;
    }
    return rslt;
}

//////////////////////////////////////////////////////////
//功能：BCD转10进制
//
//输入：const unsigned char *bcd     待转换的BCD码
//      int length                   BCD码数据长度
//
//输出：
//
//返回：unsigned long               当前数据位的权
//
//思路：压缩BCD码一个字符所表示的十进制数据范围为0 ~ 99,进制为100
//      先求每个字符所表示的十进制值，然后乘以权
//////////////////////////////////////////////////////////
unsigned long  BCD2Dec( const unsigned char* bcd, int length )
{
    int i, tmp;
    unsigned long dec = 0;
    for( i = 0; i < length; i++ )
    {
        tmp = ( ( bcd[i] >> 4 ) & 0x0F ) * 10 + ( bcd[i] & 0x0F );
        dec += tmp * (power( 100, i ));
    }
    return dec;  // 0x1234=
}

/*******************************************************************************
 * 函数名称: uint8_t Hex2BcdChar(uint8_t hex)
 * 函数功能: char型数据HEX-BCD转换
 * 入口参数: HEX数据
 * 出口参数: BCD数据
 * 注意事项: 无
*******************************************************************************/
uint8_t Hex2BcdChar( uint8_t hex )
{
    return ( ( hex % 10 ) | ( ( ( hex / 10 ) ) << 4 ) );
}

  
WORD MW(BYTE Hi,BYTE Lo)
{
	return (WORD)((Hi<<8)+Lo);
}
DWORD MDW(BYTE HH,BYTE HL,BYTE LH,BYTE LL)
{
	return (DWORD)((HH<<24) | (HL<<16) | (LH<<8) | LL);
}